home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / skbuff.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  52.3 KB  |  1,892 lines
  1. /*
  2.  *    Definitions for the 'struct sk_buff' memory handlers.
  3.  *
  4.  *    Authors:
  5.  *        Alan Cox, <gw4pts@gw4pts.ampr.org>
  6.  *        Florian La Roche, <rzsfl@rz.uni-sb.de>
  7.  *
  8.  *    This program is free software; you can redistribute it and/or
  9.  *    modify it under the terms of the GNU General Public License
  10.  *    as published by the Free Software Foundation; either version
  11.  *    2 of the License, or (at your option) any later version.
  12.  */
  13.  
  14. #ifndef _LINUX_SKBUFF_H
  15. #define _LINUX_SKBUFF_H
  16.  
  17. #include <linux/kernel.h>
  18. #include <linux/compiler.h>
  19. #include <linux/time.h>
  20. #include <linux/cache.h>
  21.  
  22. #include <asm/atomic.h>
  23. #include <asm/types.h>
  24. #include <linux/spinlock.h>
  25. #include <linux/net.h>
  26. #include <linux/textsearch.h>
  27. #include <net/checksum.h>
  28. #include <linux/rcupdate.h>
  29. #include <linux/dmaengine.h>
  30. #include <linux/hrtimer.h>
  31.  
  32. #define HAVE_ALLOC_SKB        /* For the drivers to know */
  33. #define HAVE_ALIGNABLE_SKB    /* Ditto 8)           */
  34.  
  35. /* Don't change this without changing skb_csum_unnecessary! */
  36. #define CHECKSUM_NONE 0
  37. #define CHECKSUM_UNNECESSARY 1
  38. #define CHECKSUM_COMPLETE 2
  39. #define CHECKSUM_PARTIAL 3
  40.  
  41. #define SKB_DATA_ALIGN(X)    (((X) + (SMP_CACHE_BYTES - 1)) & \
  42.                  ~(SMP_CACHE_BYTES - 1))
  43. #define SKB_WITH_OVERHEAD(X)    \
  44.     ((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
  45. #define SKB_MAX_ORDER(X, ORDER) \
  46.     SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))
  47. #define SKB_MAX_HEAD(X)        (SKB_MAX_ORDER((X), 0))
  48. #define SKB_MAX_ALLOC        (SKB_MAX_ORDER(0, 2))
  49.  
  50. /* A. Checksumming of received packets by device.
  51.  *
  52.  *    NONE: device failed to checksum this packet.
  53.  *        skb->csum is undefined.
  54.  *
  55.  *    UNNECESSARY: device parsed packet and wouldbe verified checksum.
  56.  *        skb->csum is undefined.
  57.  *          It is bad option, but, unfortunately, many of vendors do this.
  58.  *          Apparently with secret goal to sell you new device, when you
  59.  *          will add new protocol to your host. F.e. IPv6. 8)
  60.  *
  61.  *    COMPLETE: the most generic way. Device supplied checksum of _all_
  62.  *        the packet as seen by netif_rx in skb->csum.
  63.  *        NOTE: Even if device supports only some protocols, but
  64.  *        is able to produce some skb->csum, it MUST use COMPLETE,
  65.  *        not UNNECESSARY.
  66.  *
  67.  *    PARTIAL: identical to the case for output below.  This may occur
  68.  *        on a packet received directly from another Linux OS, e.g.,
  69.  *        a virtualised Linux kernel on the same host.  The packet can
  70.  *        be treated in the same way as UNNECESSARY except that on
  71.  *        output (i.e., forwarding) the checksum must be filled in
  72.  *        by the OS or the hardware.
  73.  *
  74.  * B. Checksumming on output.
  75.  *
  76.  *    NONE: skb is checksummed by protocol or csum is not required.
  77.  *
  78.  *    PARTIAL: device is required to csum packet as seen by hard_start_xmit
  79.  *    from skb->csum_start to the end and to record the checksum
  80.  *    at skb->csum_start + skb->csum_offset.
  81.  *
  82.  *    Device must show its capabilities in dev->features, set
  83.  *    at device setup time.
  84.  *    NETIF_F_HW_CSUM    - it is clever device, it is able to checksum
  85.  *              everything.
  86.  *    NETIF_F_NO_CSUM - loopback or reliable single hop media.
  87.  *    NETIF_F_IP_CSUM - device is dumb. It is able to csum only
  88.  *              TCP/UDP over IPv4. Sigh. Vendors like this
  89.  *              way by an unknown reason. Though, see comment above
  90.  *              about CHECKSUM_UNNECESSARY. 8)
  91.  *    NETIF_F_IPV6_CSUM about as dumb as the last one but does IPv6 instead.
  92.  *
  93.  *    Any questions? No questions, good.         --ANK
  94.  */
  95.  
  96. struct net_device;
  97. struct scatterlist;
  98. struct pipe_inode_info;
  99.  
  100. #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  101. struct nf_conntrack {
  102.     atomic_t use;
  103. };
  104. #endif
  105.  
  106. #ifdef CONFIG_BRIDGE_NETFILTER
  107. struct nf_bridge_info {
  108.     atomic_t use;
  109.     struct net_device *physindev;
  110.     struct net_device *physoutdev;
  111.     unsigned int mask;
  112.     unsigned long data[32 / sizeof(unsigned long)];
  113. };
  114. #endif
  115.  
  116. struct sk_buff_head {
  117.     /* These two members must be first. */
  118.     struct sk_buff    *next;
  119.     struct sk_buff    *prev;
  120.  
  121.     __u32        qlen;
  122.     spinlock_t    lock;
  123. };
  124.  
  125. struct sk_buff;
  126.  
  127. /* To allow 64K frame to be packed as single skb without frag_list */
  128. #define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2)
  129.  
  130. typedef struct skb_frag_struct skb_frag_t;
  131.  
  132. struct skb_frag_struct {
  133.     struct page *page;
  134.     __u32 page_offset;
  135.     __u32 size;
  136. };
  137.  
  138. /* This data is invariant across clones and lives at
  139.  * the end of the header data, ie. at skb->end.
  140.  */
  141. struct skb_shared_info {
  142.     atomic_t    dataref;
  143.     unsigned short    nr_frags;
  144.     unsigned short    gso_size;
  145.     /* Warning: this field is not always filled in (UFO)! */
  146.     unsigned short    gso_segs;
  147.     unsigned short  gso_type;
  148.     __be32          ip6_frag_id;
  149. #ifdef CONFIG_HAS_DMA
  150.     unsigned int    num_dma_maps;
  151. #endif
  152.     struct sk_buff    *frag_list;
  153.     skb_frag_t    frags[MAX_SKB_FRAGS];
  154. #ifdef CONFIG_HAS_DMA
  155.     dma_addr_t    dma_maps[MAX_SKB_FRAGS + 1];
  156. #endif
  157. };
  158.  
  159. /* We divide dataref into two halves.  The higher 16 bits hold references
  160.  * to the payload part of skb->data.  The lower 16 bits hold references to
  161.  * the entire skb->data.  A clone of a headerless skb holds the length of
  162.  * the header in skb->hdr_len.
  163.  *
  164.  * All users must obey the rule that the skb->data reference count must be
  165.  * greater than or equal to the payload reference count.
  166.  *
  167.  * Holding a reference to the payload part means that the user does not
  168.  * care about modifications to the header part of skb->data.
  169.  */
  170. #define SKB_DATAREF_SHIFT 16
  171. #define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT) - 1)
  172.  
  173.  
  174. enum {
  175.     SKB_FCLONE_UNAVAILABLE,
  176.     SKB_FCLONE_ORIG,
  177.     SKB_FCLONE_CLONE,
  178. };
  179.  
  180. enum {
  181.     SKB_GSO_TCPV4 = 1 << 0,
  182.     SKB_GSO_UDP = 1 << 1,
  183.  
  184.     /* This indicates the skb is from an untrusted source. */
  185.     SKB_GSO_DODGY = 1 << 2,
  186.  
  187.     /* This indicates the tcp segment has CWR set. */
  188.     SKB_GSO_TCP_ECN = 1 << 3,
  189.  
  190.     SKB_GSO_TCPV6 = 1 << 4,
  191. };
  192.  
  193. #if BITS_PER_LONG > 32
  194. #define NET_SKBUFF_DATA_USES_OFFSET 1
  195. #endif
  196.  
  197. #ifdef NET_SKBUFF_DATA_USES_OFFSET
  198. typedef unsigned int sk_buff_data_t;
  199. #else
  200. typedef unsigned char *sk_buff_data_t;
  201. #endif
  202.  
  203. /** 
  204.  *    struct sk_buff - socket buffer
  205.  *    @next: Next buffer in list
  206.  *    @prev: Previous buffer in list
  207.  *    @sk: Socket we are owned by
  208.  *    @tstamp: Time we arrived
  209.  *    @dev: Device we arrived on/are leaving by
  210.  *    @transport_header: Transport layer header
  211.  *    @network_header: Network layer header
  212.  *    @mac_header: Link layer header
  213.  *    @dst: destination entry
  214.  *    @sp: the security path, used for xfrm
  215.  *    @cb: Control buffer. Free for use by every layer. Put private vars here
  216.  *    @len: Length of actual data
  217.  *    @data_len: Data length
  218.  *    @mac_len: Length of link layer header
  219.  *    @hdr_len: writable header length of cloned skb
  220.  *    @csum: Checksum (must include start/offset pair)
  221.  *    @csum_start: Offset from skb->head where checksumming should start
  222.  *    @csum_offset: Offset from csum_start where checksum should be stored
  223.  *    @local_df: allow local fragmentation
  224.  *    @cloned: Head may be cloned (check refcnt to be sure)
  225.  *    @nohdr: Payload reference only, must not modify header
  226.  *    @pkt_type: Packet class
  227.  *    @fclone: skbuff clone status
  228.  *    @ip_summed: Driver fed us an IP checksum
  229.  *    @priority: Packet queueing priority
  230.  *    @users: User count - see {datagram,tcp}.c
  231.  *    @protocol: Packet protocol from driver
  232.  *    @truesize: Buffer size 
  233.  *    @head: Head of buffer
  234.  *    @data: Data head pointer
  235.  *    @tail: Tail pointer
  236.  *    @end: End pointer
  237.  *    @destructor: Destruct function
  238.  *    @mark: Generic packet mark
  239.  *    @nfct: Associated connection, if any
  240.  *    @ipvs_property: skbuff is owned by ipvs
  241.  *    @peeked: this packet has been seen already, so stats have been
  242.  *        done for it, don't do them again
  243.  *    @nf_trace: netfilter packet trace flag
  244.  *    @nfctinfo: Relationship of this skb to the connection
  245.  *    @nfct_reasm: netfilter conntrack re-assembly pointer
  246.  *    @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
  247.  *    @iif: ifindex of device we arrived on
  248.  *    @queue_mapping: Queue mapping for multiqueue devices
  249.  *    @tc_index: Traffic control index
  250.  *    @tc_verd: traffic control verdict
  251.  *    @ndisc_nodetype: router type (from link layer)
  252.  *    @do_not_encrypt: set to prevent encryption of this frame
  253.  *    @dma_cookie: a cookie to one of several possible DMA operations
  254.  *        done by skb DMA functions
  255.  *    @secmark: security marking
  256.  *    @vlan_tci: vlan tag control information
  257.  */
  258.  
  259. struct sk_buff {
  260.     /* These two members must be first. */
  261.     struct sk_buff        *next;
  262.     struct sk_buff        *prev;
  263.  
  264.     struct sock        *sk;
  265.     ktime_t            tstamp;
  266.     struct net_device    *dev;
  267.  
  268.     union {
  269.         struct  dst_entry    *dst;
  270.         struct  rtable        *rtable;
  271.     };
  272.     struct    sec_path    *sp;
  273.  
  274.     /*
  275.      * This is the control buffer. It is free to use for every
  276.      * layer. Please put your private variables there. If you
  277.      * want to keep them across layers you have to do a skb_clone()
  278.      * first. This is owned by whoever has the skb queued ATM.
  279.      */
  280.     char            cb[48];
  281.  
  282.     unsigned int        len,
  283.                 data_len;
  284.     __u16            mac_len,
  285.                 hdr_len;
  286.     union {
  287.         __wsum        csum;
  288.         struct {
  289.             __u16    csum_start;
  290.             __u16    csum_offset;
  291.         };
  292.     };
  293.     __u32            priority;
  294.     __u8            local_df:1,
  295.                 cloned:1,
  296.                 ip_summed:2,
  297.                 nohdr:1,
  298.                 nfctinfo:3;
  299.     __u8            pkt_type:3,
  300.                 fclone:2,
  301.                 ipvs_property:1,
  302.                 peeked:1,
  303.                 nf_trace:1;
  304.     __be16            protocol;
  305.  
  306.     void            (*destructor)(struct sk_buff *skb);
  307. #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  308.     struct nf_conntrack    *nfct;
  309.     struct sk_buff        *nfct_reasm;
  310. #endif
  311. #ifdef CONFIG_BRIDGE_NETFILTER
  312.     struct nf_bridge_info    *nf_bridge;
  313. #endif
  314.  
  315.     int            iif;
  316.     __u16            queue_mapping;
  317. #ifdef CONFIG_NET_SCHED
  318.     __u16            tc_index;    /* traffic control index */
  319. #ifdef CONFIG_NET_CLS_ACT
  320.     __u16            tc_verd;    /* traffic control verdict */
  321. #endif
  322. #endif
  323. #ifdef CONFIG_IPV6_NDISC_NODETYPE
  324.     __u8            ndisc_nodetype:2;
  325. #endif
  326. #if defined(CONFIG_MAC80211) || defined(CONFIG_MAC80211_MODULE)
  327.     __u8            do_not_encrypt:1;
  328. #endif
  329.     /* 0/13/14 bit hole */
  330.  
  331. #ifdef CONFIG_NET_DMA
  332.     dma_cookie_t        dma_cookie;
  333. #endif
  334. #ifdef CONFIG_NETWORK_SECMARK
  335.     __u32            secmark;
  336. #endif
  337.  
  338.     __u32            mark;
  339.  
  340.     __u16            vlan_tci;
  341.  
  342.     sk_buff_data_t        transport_header;
  343.     sk_buff_data_t        network_header;
  344.     sk_buff_data_t        mac_header;
  345.     /* These elements must be at the end, see alloc_skb() for details.  */
  346.     sk_buff_data_t        tail;
  347.     sk_buff_data_t        end;
  348.     unsigned char        *head,
  349.                 *data;
  350.     unsigned int        truesize;
  351.     atomic_t        users;
  352. };
  353.  
  354. #ifdef __KERNEL__
  355. /*
  356.  *    Handling routines are only of interest to the kernel
  357.  */
  358. #include <linux/slab.h>
  359.  
  360. #include <asm/system.h>
  361.  
  362. #ifdef CONFIG_HAS_DMA
  363. #include <linux/dma-mapping.h>
  364. extern int skb_dma_map(struct device *dev, struct sk_buff *skb,
  365.                enum dma_data_direction dir);
  366. extern void skb_dma_unmap(struct device *dev, struct sk_buff *skb,
  367.               enum dma_data_direction dir);
  368. #endif
  369.  
  370. extern void kfree_skb(struct sk_buff *skb);
  371. extern void           __kfree_skb(struct sk_buff *skb);
  372. extern struct sk_buff *__alloc_skb(unsigned int size,
  373.                    gfp_t priority, int fclone, int node);
  374. static inline struct sk_buff *alloc_skb(unsigned int size,
  375.                     gfp_t priority)
  376. {
  377.     return __alloc_skb(size, priority, 0, -1);
  378. }
  379.  
  380. static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
  381.                            gfp_t priority)
  382. {
  383.     return __alloc_skb(size, priority, 1, -1);
  384. }
  385.  
  386. extern int skb_recycle_check(struct sk_buff *skb, int skb_size);
  387.  
  388. extern struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
  389. extern struct sk_buff *skb_clone(struct sk_buff *skb,
  390.                  gfp_t priority);
  391. extern struct sk_buff *skb_copy(const struct sk_buff *skb,
  392.                 gfp_t priority);
  393. extern struct sk_buff *pskb_copy(struct sk_buff *skb,
  394.                  gfp_t gfp_mask);
  395. extern int           pskb_expand_head(struct sk_buff *skb,
  396.                     int nhead, int ntail,
  397.                     gfp_t gfp_mask);
  398. extern struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
  399.                         unsigned int headroom);
  400. extern struct sk_buff *skb_copy_expand(const struct sk_buff *skb,
  401.                        int newheadroom, int newtailroom,
  402.                        gfp_t priority);
  403. extern int           skb_to_sgvec(struct sk_buff *skb,
  404.                     struct scatterlist *sg, int offset,
  405.                     int len);
  406. extern int           skb_cow_data(struct sk_buff *skb, int tailbits,
  407.                     struct sk_buff **trailer);
  408. extern int           skb_pad(struct sk_buff *skb, int pad);
  409. #define dev_kfree_skb(a)    kfree_skb(a)
  410. extern void          skb_over_panic(struct sk_buff *skb, int len,
  411.                      void *here);
  412. extern void          skb_under_panic(struct sk_buff *skb, int len,
  413.                       void *here);
  414.  
  415. extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
  416.             int getfrag(void *from, char *to, int offset,
  417.             int len,int odd, struct sk_buff *skb),
  418.             void *from, int length);
  419.  
  420. struct skb_seq_state
  421. {
  422.     __u32        lower_offset;
  423.     __u32        upper_offset;
  424.     __u32        frag_idx;
  425.     __u32        stepped_offset;
  426.     struct sk_buff    *root_skb;
  427.     struct sk_buff    *cur_skb;
  428.     __u8        *frag_data;
  429. };
  430.  
  431. extern void          skb_prepare_seq_read(struct sk_buff *skb,
  432.                        unsigned int from, unsigned int to,
  433.                        struct skb_seq_state *st);
  434. extern unsigned int   skb_seq_read(unsigned int consumed, const u8 **data,
  435.                    struct skb_seq_state *st);
  436. extern void          skb_abort_seq_read(struct skb_seq_state *st);
  437.  
  438. extern unsigned int   skb_find_text(struct sk_buff *skb, unsigned int from,
  439.                     unsigned int to, struct ts_config *config,
  440.                     struct ts_state *state);
  441.  
  442. #ifdef NET_SKBUFF_DATA_USES_OFFSET
  443. static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
  444. {
  445.     return skb->head + skb->end;
  446. }
  447. #else
  448. static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
  449. {
  450.     return skb->end;
  451. }
  452. #endif
  453.  
  454. /* Internal */
  455. #define skb_shinfo(SKB)    ((struct skb_shared_info *)(skb_end_pointer(SKB)))
  456.  
  457. /**
  458.  *    skb_queue_empty - check if a queue is empty
  459.  *    @list: queue head
  460.  *
  461.  *    Returns true if the queue is empty, false otherwise.
  462.  */
  463. static inline int skb_queue_empty(const struct sk_buff_head *list)
  464. {
  465.     return list->next == (struct sk_buff *)list;
  466. }
  467.  
  468. /**
  469.  *    skb_queue_is_last - check if skb is the last entry in the queue
  470.  *    @list: queue head
  471.  *    @skb: buffer
  472.  *
  473.  *    Returns true if @skb is the last buffer on the list.
  474.  */
  475. static inline bool skb_queue_is_last(const struct sk_buff_head *list,
  476.                      const struct sk_buff *skb)
  477. {
  478.     return (skb->next == (struct sk_buff *) list);
  479. }
  480.  
  481. /**
  482.  *    skb_queue_next - return the next packet in the queue
  483.  *    @list: queue head
  484.  *    @skb: current buffer
  485.  *
  486.  *    Return the next packet in @list after @skb.  It is only valid to
  487.  *    call this if skb_queue_is_last() evaluates to false.
  488.  */
  489. static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list,
  490.                          const struct sk_buff *skb)
  491. {
  492.     /* This BUG_ON may seem severe, but if we just return then we
  493.      * are going to dereference garbage.
  494.      */
  495.     BUG_ON(skb_queue_is_last(list, skb));
  496.     return skb->next;
  497. }
  498.  
  499. /**
  500.  *    skb_get - reference buffer
  501.  *    @skb: buffer to reference
  502.  *
  503.  *    Makes another reference to a socket buffer and returns a pointer
  504.  *    to the buffer.
  505.  */
  506. static inline struct sk_buff *skb_get(struct sk_buff *skb)
  507. {
  508.     atomic_inc(&skb->users);
  509.     return skb;
  510. }
  511.  
  512. /*
  513.  * If users == 1, we are the only owner and are can avoid redundant
  514.  * atomic change.
  515.  */
  516.  
  517. /**
  518.  *    skb_cloned - is the buffer a clone
  519.  *    @skb: buffer to check
  520.  *
  521.  *    Returns true if the buffer was generated with skb_clone() and is
  522.  *    one of multiple shared copies of the buffer. Cloned buffers are
  523.  *    shared data so must not be written to under normal circumstances.
  524.  */
  525. static inline int skb_cloned(const struct sk_buff *skb)
  526. {
  527.     return skb->cloned &&
  528.            (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;
  529. }
  530.  
  531. /**
  532.  *    skb_header_cloned - is the header a clone
  533.  *    @skb: buffer to check
  534.  *
  535.  *    Returns true if modifying the header part of the buffer requires
  536.  *    the data to be copied.
  537.  */
  538. static inline int skb_header_cloned(const struct sk_buff *skb)
  539. {
  540.     int dataref;
  541.  
  542.     if (!skb->cloned)
  543.         return 0;
  544.  
  545.     dataref = atomic_read(&skb_shinfo(skb)->dataref);
  546.     dataref = (dataref & SKB_DATAREF_MASK) - (dataref >> SKB_DATAREF_SHIFT);
  547.     return dataref != 1;
  548. }
  549.  
  550. /**
  551.  *    skb_header_release - release reference to header
  552.  *    @skb: buffer to operate on
  553.  *
  554.  *    Drop a reference to the header part of the buffer.  This is done
  555.  *    by acquiring a payload reference.  You must not read from the header
  556.  *    part of skb->data after this.
  557.  */
  558. static inline void skb_header_release(struct sk_buff *skb)
  559. {
  560.     BUG_ON(skb->nohdr);
  561.     skb->nohdr = 1;
  562.     atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);
  563. }
  564.  
  565. /**
  566.  *    skb_shared - is the buffer shared
  567.  *    @skb: buffer to check
  568.  *
  569.  *    Returns true if more than one person has a reference to this
  570.  *    buffer.
  571.  */
  572. static inline int skb_shared(const struct sk_buff *skb)
  573. {
  574.     return atomic_read(&skb->users) != 1;
  575. }
  576.  
  577. /**
  578.  *    skb_share_check - check if buffer is shared and if so clone it
  579.  *    @skb: buffer to check
  580.  *    @pri: priority for memory allocation
  581.  *
  582.  *    If the buffer is shared the buffer is cloned and the old copy
  583.  *    drops a reference. A new clone with a single reference is returned.
  584.  *    If the buffer is not shared the original buffer is returned. When
  585.  *    being called from interrupt status or with spinlocks held pri must
  586.  *    be GFP_ATOMIC.
  587.  *
  588.  *    NULL is returned on a memory allocation failure.
  589.  */
  590. static inline struct sk_buff *skb_share_check(struct sk_buff *skb,
  591.                           gfp_t pri)
  592. {
  593.     might_sleep_if(pri & __GFP_WAIT);
  594.     if (skb_shared(skb)) {
  595.         struct sk_buff *nskb = skb_clone(skb, pri);
  596.         kfree_skb(skb);
  597.         skb = nskb;
  598.     }
  599.     return skb;
  600. }
  601.  
  602. /*
  603.  *    Copy shared buffers into a new sk_buff. We effectively do COW on
  604.  *    packets to handle cases where we have a local reader and forward
  605.  *    and a couple of other messy ones. The normal one is tcpdumping
  606.  *    a packet thats being forwarded.
  607.  */
  608.  
  609. /**
  610.  *    skb_unshare - make a copy of a shared buffer
  611.  *    @skb: buffer to check
  612.  *    @pri: priority for memory allocation
  613.  *
  614.  *    If the socket buffer is a clone then this function creates a new
  615.  *    copy of the data, drops a reference count on the old copy and returns
  616.  *    the new copy with the reference count at 1. If the buffer is not a clone
  617.  *    the original buffer is returned. When called with a spinlock held or
  618.  *    from interrupt state @pri must be %GFP_ATOMIC
  619.  *
  620.  *    %NULL is returned on a memory allocation failure.
  621.  */
  622. static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
  623.                       gfp_t pri)
  624. {
  625.     might_sleep_if(pri & __GFP_WAIT);
  626.     if (skb_cloned(skb)) {
  627.         struct sk_buff *nskb = skb_copy(skb, pri);
  628.         kfree_skb(skb);    /* Free our shared copy */
  629.         skb = nskb;
  630.     }
  631.     return skb;
  632. }
  633.  
  634. /**
  635.  *    skb_peek
  636.  *    @list_: list to peek at
  637.  *
  638.  *    Peek an &sk_buff. Unlike most other operations you _MUST_
  639.  *    be careful with this one. A peek leaves the buffer on the
  640.  *    list and someone else may run off with it. You must hold
  641.  *    the appropriate locks or have a private queue to do this.
  642.  *
  643.  *    Returns %NULL for an empty list or a pointer to the head element.
  644.  *    The reference count is not incremented and the reference is therefore
  645.  *    volatile. Use with caution.
  646.  */
  647. static inline struct sk_buff *skb_peek(struct sk_buff_head *list_)
  648. {
  649.     struct sk_buff *list = ((struct sk_buff *)list_)->next;
  650.     if (list == (struct sk_buff *)list_)
  651.         list = NULL;
  652.     return list;
  653. }
  654.  
  655. /**
  656.  *    skb_peek_tail
  657.  *    @list_: list to peek at
  658.  *
  659.  *    Peek an &sk_buff. Unlike most other operations you _MUST_
  660.  *    be careful with this one. A peek leaves the buffer on the
  661.  *    list and someone else may run off with it. You must hold
  662.  *    the appropriate locks or have a private queue to do this.
  663.  *
  664.  *    Returns %NULL for an empty list or a pointer to the tail element.
  665.  *    The reference count is not incremented and the reference is therefore
  666.  *    volatile. Use with caution.
  667.  */
  668. static inline struct sk_buff *skb_peek_tail(struct sk_buff_head *list_)
  669. {
  670.     struct sk_buff *list = ((struct sk_buff *)list_)->prev;
  671.     if (list == (struct sk_buff *)list_)
  672.         list = NULL;
  673.     return list;
  674. }
  675.  
  676. /**
  677.  *    skb_queue_len    - get queue length
  678.  *    @list_: list to measure
  679.  *
  680.  *    Return the length of an &sk_buff queue.
  681.  */
  682. static inline __u32 skb_queue_len(const struct sk_buff_head *list_)
  683. {
  684.     return list_->qlen;
  685. }
  686.  
  687. /**
  688.  *    __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head
  689.  *    @list: queue to initialize
  690.  *
  691.  *    This initializes only the list and queue length aspects of
  692.  *    an sk_buff_head object.  This allows to initialize the list
  693.  *    aspects of an sk_buff_head without reinitializing things like
  694.  *    the spinlock.  It can also be used for on-stack sk_buff_head
  695.  *    objects where the spinlock is known to not be used.
  696.  */
  697. static inline void __skb_queue_head_init(struct sk_buff_head *list)
  698. {
  699.     list->prev = list->next = (struct sk_buff *)list;
  700.     list->qlen = 0;
  701. }
  702.  
  703. /*
  704.  * This function creates a split out lock class for each invocation;
  705.  * this is needed for now since a whole lot of users of the skb-queue
  706.  * infrastructure in drivers have different locking usage (in hardirq)
  707.  * than the networking core (in softirq only). In the long run either the
  708.  * network layer or drivers should need annotation to consolidate the
  709.  * main types of usage into 3 classes.
  710.  */
  711. static inline void skb_queue_head_init(struct sk_buff_head *list)
  712. {
  713.     spin_lock_init(&list->lock);
  714.     __skb_queue_head_init(list);
  715. }
  716.  
  717. static inline void skb_queue_head_init_class(struct sk_buff_head *list,
  718.         struct lock_class_key *class)
  719. {
  720.     skb_queue_head_init(list);
  721.     lockdep_set_class(&list->lock, class);
  722. }
  723.  
  724. /*
  725.  *    Insert an sk_buff on a list.
  726.  *
  727.  *    The "__skb_xxxx()" functions are the non-atomic ones that
  728.  *    can only be called with interrupts disabled.
  729.  */
  730. extern void        skb_insert(struct sk_buff *old, struct sk_buff *newsk, struct sk_buff_head *list);
  731. static inline void __skb_insert(struct sk_buff *newsk,
  732.                 struct sk_buff *prev, struct sk_buff *next,
  733.                 struct sk_buff_head *list)
  734. {
  735.     newsk->next = next;
  736.     newsk->prev = prev;
  737.     next->prev  = prev->next = newsk;
  738.     list->qlen++;
  739. }
  740.  
  741. static inline void __skb_queue_splice(const struct sk_buff_head *list,
  742.                       struct sk_buff *prev,
  743.                       struct sk_buff *next)
  744. {
  745.     struct sk_buff *first = list->next;
  746.     struct sk_buff *last = list->prev;
  747.  
  748.     first->prev = prev;
  749.     prev->next = first;
  750.  
  751.     last->next = next;
  752.     next->prev = last;
  753. }
  754.  
  755. /**
  756.  *    skb_queue_splice - join two skb lists, this is designed for stacks
  757.  *    @list: the new list to add
  758.  *    @head: the place to add it in the first list
  759.  */
  760. static inline void skb_queue_splice(const struct sk_buff_head *list,
  761.                     struct sk_buff_head *head)
  762. {
  763.     if (!skb_queue_empty(list)) {
  764.         __skb_queue_splice(list, (struct sk_buff *) head, head->next);
  765.         head->qlen += list->qlen;
  766.     }
  767. }
  768.  
  769. /**
  770.  *    skb_queue_splice - join two skb lists and reinitialise the emptied list
  771.  *    @list: the new list to add
  772.  *    @head: the place to add it in the first list
  773.  *
  774.  *    The list at @list is reinitialised
  775.  */
  776. static inline void skb_queue_splice_init(struct sk_buff_head *list,
  777.                      struct sk_buff_head *head)
  778. {
  779.     if (!skb_queue_empty(list)) {
  780.         __skb_queue_splice(list, (struct sk_buff *) head, head->next);
  781.         head->qlen += list->qlen;
  782.         __skb_queue_head_init(list);
  783.     }
  784. }
  785.  
  786. /**
  787.  *    skb_queue_splice_tail - join two skb lists, each list being a queue
  788.  *    @list: the new list to add
  789.  *    @head: the place to add it in the first list
  790.  */
  791. static inline void skb_queue_splice_tail(const struct sk_buff_head *list,
  792.                      struct sk_buff_head *head)
  793. {
  794.     if (!skb_queue_empty(list)) {
  795.         __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
  796.         head->qlen += list->qlen;
  797.     }
  798. }
  799.  
  800. /**
  801.  *    skb_queue_splice_tail - join two skb lists and reinitialise the emptied list
  802.  *    @list: the new list to add
  803.  *    @head: the place to add it in the first list
  804.  *
  805.  *    Each of the lists is a queue.
  806.  *    The list at @list is reinitialised
  807.  */
  808. static inline void skb_queue_splice_tail_init(struct sk_buff_head *list,
  809.                           struct sk_buff_head *head)
  810. {
  811.     if (!skb_queue_empty(list)) {
  812.         __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
  813.         head->qlen += list->qlen;
  814.         __skb_queue_head_init(list);
  815.     }
  816. }
  817.  
  818. /**
  819.  *    __skb_queue_after - queue a buffer at the list head
  820.  *    @list: list to use
  821.  *    @prev: place after this buffer
  822.  *    @newsk: buffer to queue
  823.  *
  824.  *    Queue a buffer int the middle of a list. This function takes no locks
  825.  *    and you must therefore hold required locks before calling it.
  826.  *
  827.  *    A buffer cannot be placed on two lists at the same time.
  828.  */
  829. static inline void __skb_queue_after(struct sk_buff_head *list,
  830.                      struct sk_buff *prev,
  831.                      struct sk_buff *newsk)
  832. {
  833.     __skb_insert(newsk, prev, prev->next, list);
  834. }
  835.  
  836. extern void skb_append(struct sk_buff *old, struct sk_buff *newsk,
  837.                struct sk_buff_head *list);
  838.  
  839. static inline void __skb_queue_before(struct sk_buff_head *list,
  840.                       struct sk_buff *next,
  841.                       struct sk_buff *newsk)
  842. {
  843.     __skb_insert(newsk, next->prev, next, list);
  844. }
  845.  
  846. /**
  847.  *    __skb_queue_head - queue a buffer at the list head
  848.  *    @list: list to use
  849.  *    @newsk: buffer to queue
  850.  *
  851.  *    Queue a buffer at the start of a list. This function takes no locks
  852.  *    and you must therefore hold required locks before calling it.
  853.  *
  854.  *    A buffer cannot be placed on two lists at the same time.
  855.  */
  856. extern void skb_queue_head(struct sk_buff_head *list, struct sk_buff *newsk);
  857. static inline void __skb_queue_head(struct sk_buff_head *list,
  858.                     struct sk_buff *newsk)
  859. {
  860.     __skb_queue_after(list, (struct sk_buff *)list, newsk);
  861. }
  862.  
  863. /**
  864.  *    __skb_queue_tail - queue a buffer at the list tail
  865.  *    @list: list to use
  866.  *    @newsk: buffer to queue
  867.  *
  868.  *    Queue a buffer at the end of a list. This function takes no locks
  869.  *    and you must therefore hold required locks before calling it.
  870.  *
  871.  *    A buffer cannot be placed on two lists at the same time.
  872.  */
  873. extern void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
  874. static inline void __skb_queue_tail(struct sk_buff_head *list,
  875.                    struct sk_buff *newsk)
  876. {
  877.     __skb_queue_before(list, (struct sk_buff *)list, newsk);
  878. }
  879.  
  880. /*
  881.  * remove sk_buff from list. _Must_ be called atomically, and with
  882.  * the list known..
  883.  */
  884. extern void       skb_unlink(struct sk_buff *skb, struct sk_buff_head *list);
  885. static inline void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
  886. {
  887.     struct sk_buff *next, *prev;
  888.  
  889.     list->qlen--;
  890.     next       = skb->next;
  891.     prev       = skb->prev;
  892.     skb->next  = skb->prev = NULL;
  893.     next->prev = prev;
  894.     prev->next = next;
  895. }
  896.  
  897. /**
  898.  *    __skb_dequeue - remove from the head of the queue
  899.  *    @list: list to dequeue from
  900.  *
  901.  *    Remove the head of the list. This function does not take any locks
  902.  *    so must be used with appropriate locks held only. The head item is
  903.  *    returned or %NULL if the list is empty.
  904.  */
  905. extern struct sk_buff *skb_dequeue(struct sk_buff_head *list);
  906. static inline struct sk_buff *__skb_dequeue(struct sk_buff_head *list)
  907. {
  908.     struct sk_buff *skb = skb_peek(list);
  909.     if (skb)
  910.         __skb_unlink(skb, list);
  911.     return skb;
  912. }
  913.  
  914. /**
  915.  *    __skb_dequeue_tail - remove from the tail of the queue
  916.  *    @list: list to dequeue from
  917.  *
  918.  *    Remove the tail of the list. This function does not take any locks
  919.  *    so must be used with appropriate locks held only. The tail item is
  920.  *    returned or %NULL if the list is empty.
  921.  */
  922. extern struct sk_buff *skb_dequeue_tail(struct sk_buff_head *list);
  923. static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
  924. {
  925.     struct sk_buff *skb = skb_peek_tail(list);
  926.     if (skb)
  927.         __skb_unlink(skb, list);
  928.     return skb;
  929. }
  930.  
  931.  
  932. static inline int skb_is_nonlinear(const struct sk_buff *skb)
  933. {
  934.     return skb->data_len;
  935. }
  936.  
  937. static inline unsigned int skb_headlen(const struct sk_buff *skb)
  938. {
  939.     return skb->len - skb->data_len;
  940. }
  941.  
  942. static inline int skb_pagelen(const struct sk_buff *skb)
  943. {
  944.     int i, len = 0;
  945.  
  946.     for (i = (int)skb_shinfo(skb)->nr_frags - 1; i >= 0; i--)
  947.         len += skb_shinfo(skb)->frags[i].size;
  948.     return len + skb_headlen(skb);
  949. }
  950.  
  951. static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
  952.                       struct page *page, int off, int size)
  953. {
  954.     skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
  955.  
  956.     frag->page          = page;
  957.     frag->page_offset      = off;
  958.     frag->size          = size;
  959.     skb_shinfo(skb)->nr_frags = i + 1;
  960. }
  961.  
  962. extern void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page,
  963.                 int off, int size);
  964.  
  965. #define SKB_PAGE_ASSERT(skb)     BUG_ON(skb_shinfo(skb)->nr_frags)
  966. #define SKB_FRAG_ASSERT(skb)     BUG_ON(skb_shinfo(skb)->frag_list)
  967. #define SKB_LINEAR_ASSERT(skb)  BUG_ON(skb_is_nonlinear(skb))
  968.  
  969. #ifdef NET_SKBUFF_DATA_USES_OFFSET
  970. static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
  971. {
  972.     return skb->head + skb->tail;
  973. }
  974.  
  975. static inline void skb_reset_tail_pointer(struct sk_buff *skb)
  976. {
  977.     skb->tail = skb->data - skb->head;
  978. }
  979.  
  980. static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
  981. {
  982.     skb_reset_tail_pointer(skb);
  983.     skb->tail += offset;
  984. }
  985. #else /* NET_SKBUFF_DATA_USES_OFFSET */
  986. static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb)
  987. {
  988.     return skb->tail;
  989. }
  990.  
  991. static inline void skb_reset_tail_pointer(struct sk_buff *skb)
  992. {
  993.     skb->tail = skb->data;
  994. }
  995.  
  996. static inline void skb_set_tail_pointer(struct sk_buff *skb, const int offset)
  997. {
  998.     skb->tail = skb->data + offset;
  999. }
  1000.  
  1001. #endif /* NET_SKBUFF_DATA_USES_OFFSET */
  1002.  
  1003. /*
  1004.  *    Add data to an sk_buff
  1005.  */
  1006. extern unsigned char *skb_put(struct sk_buff *skb, unsigned int len);
  1007. static inline unsigned char *__skb_put(struct sk_buff *skb, unsigned int len)
  1008. {
  1009.     unsigned char *tmp = skb_tail_pointer(skb);
  1010.     SKB_LINEAR_ASSERT(skb);
  1011.     skb->tail += len;
  1012.     skb->len  += len;
  1013.     return tmp;
  1014. }
  1015.  
  1016. extern unsigned char *skb_push(struct sk_buff *skb, unsigned int len);
  1017. static inline unsigned char *__skb_push(struct sk_buff *skb, unsigned int len)
  1018. {
  1019.     skb->data -= len;
  1020.     skb->len  += len;
  1021.     return skb->data;
  1022. }
  1023.  
  1024. extern unsigned char *skb_pull(struct sk_buff *skb, unsigned int len);
  1025. static inline unsigned char *__skb_pull(struct sk_buff *skb, unsigned int len)
  1026. {
  1027.     skb->len -= len;
  1028.     BUG_ON(skb->len < skb->data_len);
  1029.     return skb->data += len;
  1030. }
  1031.  
  1032. extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
  1033.  
  1034. static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
  1035. {
  1036.     if (len > skb_headlen(skb) &&
  1037.         !__pskb_pull_tail(skb, len - skb_headlen(skb)))
  1038.         return NULL;
  1039.     skb->len -= len;
  1040.     return skb->data += len;
  1041. }
  1042.  
  1043. static inline unsigned char *pskb_pull(struct sk_buff *skb, unsigned int len)
  1044. {
  1045.     return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
  1046. }
  1047.  
  1048. static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
  1049. {
  1050.     if (likely(len <= skb_headlen(skb)))
  1051.         return 1;
  1052.     if (unlikely(len > skb->len))
  1053.         return 0;
  1054.     return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;
  1055. }
  1056.  
  1057. /**
  1058.  *    skb_headroom - bytes at buffer head
  1059.  *    @skb: buffer to check
  1060.  *
  1061.  *    Return the number of bytes of free space at the head of an &sk_buff.
  1062.  */
  1063. static inline unsigned int skb_headroom(const struct sk_buff *skb)
  1064. {
  1065.     return skb->data - skb->head;
  1066. }
  1067.  
  1068. /**
  1069.  *    skb_tailroom - bytes at buffer end
  1070.  *    @skb: buffer to check
  1071.  *
  1072.  *    Return the number of bytes of free space at the tail of an sk_buff
  1073.  */
  1074. static inline int skb_tailroom(const struct sk_buff *skb)
  1075. {
  1076.     return skb_is_nonlinear(skb) ? 0 : skb->end - skb->tail;
  1077. }
  1078.  
  1079. /**
  1080.  *    skb_reserve - adjust headroom
  1081.  *    @skb: buffer to alter
  1082.  *    @len: bytes to move
  1083.  *
  1084.  *    Increase the headroom of an empty &sk_buff by reducing the tail
  1085.  *    room. This is only allowed for an empty buffer.
  1086.  */
  1087. static inline void skb_reserve(struct sk_buff *skb, int len)
  1088. {
  1089.     skb->data += len;
  1090.     skb->tail += len;
  1091. }
  1092.  
  1093. #ifdef NET_SKBUFF_DATA_USES_OFFSET
  1094. static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
  1095. {
  1096.     return skb->head + skb->transport_header;
  1097. }
  1098.  
  1099. static inline void skb_reset_transport_header(struct sk_buff *skb)
  1100. {
  1101.     skb->transport_header = skb->data - skb->head;
  1102. }
  1103.  
  1104. static inline void skb_set_transport_header(struct sk_buff *skb,
  1105.                         const int offset)
  1106. {
  1107.     skb_reset_transport_header(skb);
  1108.     skb->transport_header += offset;
  1109. }
  1110.  
  1111. static inline unsigned char *skb_network_header(const struct sk_buff *skb)
  1112. {
  1113.     return skb->head + skb->network_header;
  1114. }
  1115.  
  1116. static inline void skb_reset_network_header(struct sk_buff *skb)
  1117. {
  1118.     skb->network_header = skb->data - skb->head;
  1119. }
  1120.  
  1121. static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
  1122. {
  1123.     skb_reset_network_header(skb);
  1124.     skb->network_header += offset;
  1125. }
  1126.  
  1127. static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
  1128. {
  1129.     return skb->head + skb->mac_header;
  1130. }
  1131.  
  1132. static inline int skb_mac_header_was_set(const struct sk_buff *skb)
  1133. {
  1134.     return skb->mac_header != ~0U;
  1135. }
  1136.  
  1137. static inline void skb_reset_mac_header(struct sk_buff *skb)
  1138. {
  1139.     skb->mac_header = skb->data - skb->head;
  1140. }
  1141.  
  1142. static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
  1143. {
  1144.     skb_reset_mac_header(skb);
  1145.     skb->mac_header += offset;
  1146. }
  1147.  
  1148. #else /* NET_SKBUFF_DATA_USES_OFFSET */
  1149.  
  1150. static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
  1151. {
  1152.     return skb->transport_header;
  1153. }
  1154.  
  1155. static inline void skb_reset_transport_header(struct sk_buff *skb)
  1156. {
  1157.     skb->transport_header = skb->data;
  1158. }
  1159.  
  1160. static inline void skb_set_transport_header(struct sk_buff *skb,
  1161.                         const int offset)
  1162. {
  1163.     skb->transport_header = skb->data + offset;
  1164. }
  1165.  
  1166. static inline unsigned char *skb_network_header(const struct sk_buff *skb)
  1167. {
  1168.     return skb->network_header;
  1169. }
  1170.  
  1171. static inline void skb_reset_network_header(struct sk_buff *skb)
  1172. {
  1173.     skb->network_header = skb->data;
  1174. }
  1175.  
  1176. static inline void skb_set_network_header(struct sk_buff *skb, const int offset)
  1177. {
  1178.     skb->network_header = skb->data + offset;
  1179. }
  1180.  
  1181. static inline unsigned char *skb_mac_header(const struct sk_buff *skb)
  1182. {
  1183.     return skb->mac_header;
  1184. }
  1185.  
  1186. static inline int skb_mac_header_was_set(const struct sk_buff *skb)
  1187. {
  1188.     return skb->mac_header != NULL;
  1189. }
  1190.  
  1191. static inline void skb_reset_mac_header(struct sk_buff *skb)
  1192. {
  1193.     skb->mac_header = skb->data;
  1194. }
  1195.  
  1196. static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
  1197. {
  1198.     skb->mac_header = skb->data + offset;
  1199. }
  1200. #endif /* NET_SKBUFF_DATA_USES_OFFSET */
  1201.  
  1202. static inline int skb_transport_offset(const struct sk_buff *skb)
  1203. {
  1204.     return skb_transport_header(skb) - skb->data;
  1205. }
  1206.  
  1207. static inline u32 skb_network_header_len(const struct sk_buff *skb)
  1208. {
  1209.     return skb->transport_header - skb->network_header;
  1210. }
  1211.  
  1212. static inline int skb_network_offset(const struct sk_buff *skb)
  1213. {
  1214.     return skb_network_header(skb) - skb->data;
  1215. }
  1216.  
  1217. /*
  1218.  * CPUs often take a performance hit when accessing unaligned memory
  1219.  * locations. The actual performance hit varies, it can be small if the
  1220.  * hardware handles it or large if we have to take an exception and fix it
  1221.  * in software.
  1222.  *
  1223.  * Since an ethernet header is 14 bytes network drivers often end up with
  1224.  * the IP header at an unaligned offset. The IP header can be aligned by
  1225.  * shifting the start of the packet by 2 bytes. Drivers should do this
  1226.  * with:
  1227.  *
  1228.  * skb_reserve(NET_IP_ALIGN);
  1229.  *
  1230.  * The downside to this alignment of the IP header is that the DMA is now
  1231.  * unaligned. On some architectures the cost of an unaligned DMA is high
  1232.  * and this cost outweighs the gains made by aligning the IP header.
  1233.  * 
  1234.  * Since this trade off varies between architectures, we allow NET_IP_ALIGN
  1235.  * to be overridden.
  1236.  */
  1237. #ifndef NET_IP_ALIGN
  1238. #define NET_IP_ALIGN    2
  1239. #endif
  1240.  
  1241. /*
  1242.  * The networking layer reserves some headroom in skb data (via
  1243.  * dev_alloc_skb). This is used to avoid having to reallocate skb data when
  1244.  * the header has to grow. In the default case, if the header has to grow
  1245.  * 16 bytes or less we avoid the reallocation.
  1246.  *
  1247.  * Unfortunately this headroom changes the DMA alignment of the resulting
  1248.  * network packet. As for NET_IP_ALIGN, this unaligned DMA is expensive
  1249.  * on some architectures. An architecture can override this value,
  1250.  * perhaps setting it to a cacheline in size (since that will maintain
  1251.  * cacheline alignment of the DMA). It must be a power of 2.
  1252.  *
  1253.  * Various parts of the networking layer expect at least 16 bytes of
  1254.  * headroom, you should not reduce this.
  1255.  */
  1256. #ifndef NET_SKB_PAD
  1257. #define NET_SKB_PAD    16
  1258. #endif
  1259.  
  1260. extern int ___pskb_trim(struct sk_buff *skb, unsigned int len);
  1261.  
  1262. static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
  1263. {
  1264.     if (unlikely(skb->data_len)) {
  1265.         WARN_ON(1);
  1266.         return;
  1267.     }
  1268.     skb->len = len;
  1269.     skb_set_tail_pointer(skb, len);
  1270. }
  1271.  
  1272. extern void skb_trim(struct sk_buff *skb, unsigned int len);
  1273.  
  1274. static inline int __pskb_trim(struct sk_buff *skb, unsigned int len)
  1275. {
  1276.     if (skb->data_len)
  1277.         return ___pskb_trim(skb, len);
  1278.     __skb_trim(skb, len);
  1279.     return 0;
  1280. }
  1281.  
  1282. static inline int pskb_trim(struct sk_buff *skb, unsigned int len)
  1283. {
  1284.     return (len < skb->len) ? __pskb_trim(skb, len) : 0;
  1285. }
  1286.  
  1287. /**
  1288.  *    pskb_trim_unique - remove end from a paged unique (not cloned) buffer
  1289.  *    @skb: buffer to alter
  1290.  *    @len: new length
  1291.  *
  1292.  *    This is identical to pskb_trim except that the caller knows that
  1293.  *    the skb is not cloned so we should never get an error due to out-
  1294.  *    of-memory.
  1295.  */
  1296. static inline void pskb_trim_unique(struct sk_buff *skb, unsigned int len)
  1297. {
  1298.     int err = pskb_trim(skb, len);
  1299.     BUG_ON(err);
  1300. }
  1301.  
  1302. /**
  1303.  *    skb_orphan - orphan a buffer
  1304.  *    @skb: buffer to orphan
  1305.  *
  1306.  *    If a buffer currently has an owner then we call the owner's
  1307.  *    destructor function and make the @skb unowned. The buffer continues
  1308.  *    to exist but is no longer charged to its former owner.
  1309.  */
  1310. static inline void skb_orphan(struct sk_buff *skb)
  1311. {
  1312.     if (skb->destructor)
  1313.         skb->destructor(skb);
  1314.     skb->destructor = NULL;
  1315.     skb->sk        = NULL;
  1316. }
  1317.  
  1318. /**
  1319.  *    __skb_queue_purge - empty a list
  1320.  *    @list: list to empty
  1321.  *
  1322.  *    Delete all buffers on an &sk_buff list. Each buffer is removed from
  1323.  *    the list and one reference dropped. This function does not take the
  1324.  *    list lock and the caller must hold the relevant locks to use it.
  1325.  */
  1326. extern void skb_queue_purge(struct sk_buff_head *list);
  1327. static inline void __skb_queue_purge(struct sk_buff_head *list)
  1328. {
  1329.     struct sk_buff *skb;
  1330.     while ((skb = __skb_dequeue(list)) != NULL)
  1331.         kfree_skb(skb);
  1332. }
  1333.  
  1334. /**
  1335.  *    __dev_alloc_skb - allocate an skbuff for receiving
  1336.  *    @length: length to allocate
  1337.  *    @gfp_mask: get_free_pages mask, passed to alloc_skb
  1338.  *
  1339.  *    Allocate a new &sk_buff and assign it a usage count of one. The
  1340.  *    buffer has unspecified headroom built in. Users should allocate
  1341.  *    the headroom they think they need without accounting for the
  1342.  *    built in space. The built in space is used for optimisations.
  1343.  *
  1344.  *    %NULL is returned if there is no free memory.
  1345.  */
  1346. static inline struct sk_buff *__dev_alloc_skb(unsigned int length,
  1347.                           gfp_t gfp_mask)
  1348. {
  1349.     struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask);
  1350.     if (likely(skb))
  1351.         skb_reserve(skb, NET_SKB_PAD);
  1352.     return skb;
  1353. }
  1354.  
  1355. extern struct sk_buff *dev_alloc_skb(unsigned int length);
  1356.  
  1357. extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
  1358.         unsigned int length, gfp_t gfp_mask);
  1359.  
  1360. /**
  1361.  *    netdev_alloc_skb - allocate an skbuff for rx on a specific device
  1362.  *    @dev: network device to receive on
  1363.  *    @length: length to allocate
  1364.  *
  1365.  *    Allocate a new &sk_buff and assign it a usage count of one. The
  1366.  *    buffer has unspecified headroom built in. Users should allocate
  1367.  *    the headroom they think they need without accounting for the
  1368.  *    built in space. The built in space is used for optimisations.
  1369.  *
  1370.  *    %NULL is returned if there is no free memory. Although this function
  1371.  *    allocates memory it can be called from an interrupt.
  1372.  */
  1373. static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
  1374.         unsigned int length)
  1375. {
  1376.     return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
  1377. }
  1378.  
  1379. extern struct page *__netdev_alloc_page(struct net_device *dev, gfp_t gfp_mask);
  1380.  
  1381. /**
  1382.  *    netdev_alloc_page - allocate a page for ps-rx on a specific device
  1383.  *    @dev: network device to receive on
  1384.  *
  1385.  *     Allocate a new page node local to the specified device.
  1386.  *
  1387.  *     %NULL is returned if there is no free memory.
  1388.  */
  1389. static inline struct page *netdev_alloc_page(struct net_device *dev)
  1390. {
  1391.     return __netdev_alloc_page(dev, GFP_ATOMIC);
  1392. }
  1393.  
  1394. static inline void netdev_free_page(struct net_device *dev, struct page *page)
  1395. {
  1396.     __free_page(page);
  1397. }
  1398.  
  1399. /**
  1400.  *    skb_clone_writable - is the header of a clone writable
  1401.  *    @skb: buffer to check
  1402.  *    @len: length up to which to write
  1403.  *
  1404.  *    Returns true if modifying the header part of the cloned buffer
  1405.  *    does not requires the data to be copied.
  1406.  */
  1407. static inline int skb_clone_writable(struct sk_buff *skb, unsigned int len)
  1408. {
  1409.     return !skb_header_cloned(skb) &&
  1410.            skb_headroom(skb) + len <= skb->hdr_len;
  1411. }
  1412.  
  1413. static inline int __skb_cow(struct sk_buff *skb, unsigned int headroom,
  1414.                 int cloned)
  1415. {
  1416.     int delta = 0;
  1417.  
  1418.     if (headroom < NET_SKB_PAD)
  1419.         headroom = NET_SKB_PAD;
  1420.     if (headroom > skb_headroom(skb))
  1421.         delta = headroom - skb_headroom(skb);
  1422.  
  1423.     if (delta || cloned)
  1424.         return pskb_expand_head(skb, ALIGN(delta, NET_SKB_PAD), 0,
  1425.                     GFP_ATOMIC);
  1426.     return 0;
  1427. }
  1428.  
  1429. /**
  1430.  *    skb_cow - copy header of skb when it is required
  1431.  *    @skb: buffer to cow
  1432.  *    @headroom: needed headroom
  1433.  *
  1434.  *    If the skb passed lacks sufficient headroom or its data part
  1435.  *    is shared, data is reallocated. If reallocation fails, an error
  1436.  *    is returned and original skb is not changed.
  1437.  *
  1438.  *    The result is skb with writable area skb->head...skb->tail
  1439.  *    and at least @headroom of space at head.
  1440.  */
  1441. static inline int skb_cow(struct sk_buff *skb, unsigned int headroom)
  1442. {
  1443.     return __skb_cow(skb, headroom, skb_cloned(skb));
  1444. }
  1445.  
  1446. /**
  1447.  *    skb_cow_head - skb_cow but only making the head writable
  1448.  *    @skb: buffer to cow
  1449.  *    @headroom: needed headroom
  1450.  *
  1451.  *    This function is identical to skb_cow except that we replace the
  1452.  *    skb_cloned check by skb_header_cloned.  It should be used when
  1453.  *    you only need to push on some header and do not need to modify
  1454.  *    the data.
  1455.  */
  1456. static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom)
  1457. {
  1458.     return __skb_cow(skb, headroom, skb_header_cloned(skb));
  1459. }
  1460.  
  1461. /**
  1462.  *    skb_padto    - pad an skbuff up to a minimal size
  1463.  *    @skb: buffer to pad
  1464.  *    @len: minimal length
  1465.  *
  1466.  *    Pads up a buffer to ensure the trailing bytes exist and are
  1467.  *    blanked. If the buffer already contains sufficient data it
  1468.  *    is untouched. Otherwise it is extended. Returns zero on
  1469.  *    success. The skb is freed on error.
  1470.  */
  1471.  
  1472. static inline int skb_padto(struct sk_buff *skb, unsigned int len)
  1473. {
  1474.     unsigned int size = skb->len;
  1475.     if (likely(size >= len))
  1476.         return 0;
  1477.     return skb_pad(skb, len - size);
  1478. }
  1479.  
  1480. static inline int skb_add_data(struct sk_buff *skb,
  1481.                    char __user *from, int copy)
  1482. {
  1483.     const int off = skb->len;
  1484.  
  1485.     if (skb->ip_summed == CHECKSUM_NONE) {
  1486.         int err = 0;
  1487.         __wsum csum = csum_and_copy_from_user(from, skb_put(skb, copy),
  1488.                                 copy, 0, &err);
  1489.         if (!err) {
  1490.             skb->csum = csum_block_add(skb->csum, csum, off);
  1491.             return 0;
  1492.         }
  1493.     } else if (!copy_from_user(skb_put(skb, copy), from, copy))
  1494.         return 0;
  1495.  
  1496.     __skb_trim(skb, off);
  1497.     return -EFAULT;
  1498. }
  1499.  
  1500. static inline int skb_can_coalesce(struct sk_buff *skb, int i,
  1501.                    struct page *page, int off)
  1502. {
  1503.     if (i) {
  1504.         struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i - 1];
  1505.  
  1506.         return page == frag->page &&
  1507.                off == frag->page_offset + frag->size;
  1508.     }
  1509.     return 0;
  1510. }
  1511.  
  1512. static inline int __skb_linearize(struct sk_buff *skb)
  1513. {
  1514.     return __pskb_pull_tail(skb, skb->data_len) ? 0 : -ENOMEM;
  1515. }
  1516.  
  1517. /**
  1518.  *    skb_linearize - convert paged skb to linear one
  1519.  *    @skb: buffer to linarize
  1520.  *
  1521.  *    If there is no free memory -ENOMEM is returned, otherwise zero
  1522.  *    is returned and the old skb data released.
  1523.  */
  1524. static inline int skb_linearize(struct sk_buff *skb)
  1525. {
  1526.     return skb_is_nonlinear(skb) ? __skb_linearize(skb) : 0;
  1527. }
  1528.  
  1529. /**
  1530.  *    skb_linearize_cow - make sure skb is linear and writable
  1531.  *    @skb: buffer to process
  1532.  *
  1533.  *    If there is no free memory -ENOMEM is returned, otherwise zero
  1534.  *    is returned and the old skb data released.
  1535.  */
  1536. static inline int skb_linearize_cow(struct sk_buff *skb)
  1537. {
  1538.     return skb_is_nonlinear(skb) || skb_cloned(skb) ?
  1539.            __skb_linearize(skb) : 0;
  1540. }
  1541.  
  1542. /**
  1543.  *    skb_postpull_rcsum - update checksum for received skb after pull
  1544.  *    @skb: buffer to update
  1545.  *    @start: start of data before pull
  1546.  *    @len: length of data pulled
  1547.  *
  1548.  *    After doing a pull on a received packet, you need to call this to
  1549.  *    update the CHECKSUM_COMPLETE checksum, or set ip_summed to
  1550.  *    CHECKSUM_NONE so that it can be recomputed from scratch.
  1551.  */
  1552.  
  1553. static inline void skb_postpull_rcsum(struct sk_buff *skb,
  1554.                       const void *start, unsigned int len)
  1555. {
  1556.     if (skb->ip_summed == CHECKSUM_COMPLETE)
  1557.         skb->csum = csum_sub(skb->csum, csum_partial(start, len, 0));
  1558. }
  1559.  
  1560. unsigned char *skb_pull_rcsum(struct sk_buff *skb, unsigned int len);
  1561.  
  1562. /**
  1563.  *    pskb_trim_rcsum - trim received skb and update checksum
  1564.  *    @skb: buffer to trim
  1565.  *    @len: new length
  1566.  *
  1567.  *    This is exactly the same as pskb_trim except that it ensures the
  1568.  *    checksum of received packets are still valid after the operation.
  1569.  */
  1570.  
  1571. static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
  1572. {
  1573.     if (likely(len >= skb->len))
  1574.         return 0;
  1575.     if (skb->ip_summed == CHECKSUM_COMPLETE)
  1576.         skb->ip_summed = CHECKSUM_NONE;
  1577.     return __pskb_trim(skb, len);
  1578. }
  1579.  
  1580. #define skb_queue_walk(queue, skb) \
  1581.         for (skb = (queue)->next;                    \
  1582.              prefetch(skb->next), (skb != (struct sk_buff *)(queue));    \
  1583.              skb = skb->next)
  1584.  
  1585. #define skb_queue_walk_safe(queue, skb, tmp)                    \
  1586.         for (skb = (queue)->next, tmp = skb->next;            \
  1587.              skb != (struct sk_buff *)(queue);                \
  1588.              skb = tmp, tmp = skb->next)
  1589.  
  1590. #define skb_queue_walk_from(queue, skb)                        \
  1591.         for (; prefetch(skb->next), (skb != (struct sk_buff *)(queue));    \
  1592.              skb = skb->next)
  1593.  
  1594. #define skb_queue_walk_from_safe(queue, skb, tmp)                \
  1595.         for (tmp = skb->next;                        \
  1596.              skb != (struct sk_buff *)(queue);                \
  1597.              skb = tmp, tmp = skb->next)
  1598.  
  1599. #define skb_queue_reverse_walk(queue, skb) \
  1600.         for (skb = (queue)->prev;                    \
  1601.              prefetch(skb->prev), (skb != (struct sk_buff *)(queue));    \
  1602.              skb = skb->prev)
  1603.  
  1604.  
  1605. extern struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
  1606.                        int *peeked, int *err);
  1607. extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
  1608.                      int noblock, int *err);
  1609. extern unsigned int    datagram_poll(struct file *file, struct socket *sock,
  1610.                      struct poll_table_struct *wait);
  1611. extern int           skb_copy_datagram_iovec(const struct sk_buff *from,
  1612.                            int offset, struct iovec *to,
  1613.                            int size);
  1614. extern int           skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
  1615.                             int hlen,
  1616.                             struct iovec *iov);
  1617. extern int           skb_copy_datagram_from_iovec(struct sk_buff *skb,
  1618.                             int offset,
  1619.                             struct iovec *from,
  1620.                             int len);
  1621. extern void           skb_free_datagram(struct sock *sk, struct sk_buff *skb);
  1622. extern int           skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
  1623.                      unsigned int flags);
  1624. extern __wsum           skb_checksum(const struct sk_buff *skb, int offset,
  1625.                     int len, __wsum csum);
  1626. extern int           skb_copy_bits(const struct sk_buff *skb, int offset,
  1627.                      void *to, int len);
  1628. extern int           skb_store_bits(struct sk_buff *skb, int offset,
  1629.                       const void *from, int len);
  1630. extern __wsum           skb_copy_and_csum_bits(const struct sk_buff *skb,
  1631.                           int offset, u8 *to, int len,
  1632.                           __wsum csum);
  1633. extern int             skb_splice_bits(struct sk_buff *skb,
  1634.                         unsigned int offset,
  1635.                         struct pipe_inode_info *pipe,
  1636.                         unsigned int len,
  1637.                         unsigned int flags);
  1638. extern void           skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
  1639. extern void           skb_split(struct sk_buff *skb,
  1640.                  struct sk_buff *skb1, const u32 len);
  1641.  
  1642. extern struct sk_buff *skb_segment(struct sk_buff *skb, int features);
  1643.  
  1644. static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
  1645.                        int len, void *buffer)
  1646. {
  1647.     int hlen = skb_headlen(skb);
  1648.  
  1649.     if (hlen - offset >= len)
  1650.         return skb->data + offset;
  1651.  
  1652.     if (skb_copy_bits(skb, offset, buffer, len) < 0)
  1653.         return NULL;
  1654.  
  1655.     return buffer;
  1656. }
  1657.  
  1658. static inline void skb_copy_from_linear_data(const struct sk_buff *skb,
  1659.                          void *to,
  1660.                          const unsigned int len)
  1661. {
  1662.     memcpy(to, skb->data, len);
  1663. }
  1664.  
  1665. static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb,
  1666.                             const int offset, void *to,
  1667.                             const unsigned int len)
  1668. {
  1669.     memcpy(to, skb->data + offset, len);
  1670. }
  1671.  
  1672. static inline void skb_copy_to_linear_data(struct sk_buff *skb,
  1673.                        const void *from,
  1674.                        const unsigned int len)
  1675. {
  1676.     memcpy(skb->data, from, len);
  1677. }
  1678.  
  1679. static inline void skb_copy_to_linear_data_offset(struct sk_buff *skb,
  1680.                           const int offset,
  1681.                           const void *from,
  1682.                           const unsigned int len)
  1683. {
  1684.     memcpy(skb->data + offset, from, len);
  1685. }
  1686.  
  1687. extern void skb_init(void);
  1688.  
  1689. /**
  1690.  *    skb_get_timestamp - get timestamp from a skb
  1691.  *    @skb: skb to get stamp from
  1692.  *    @stamp: pointer to struct timeval to store stamp in
  1693.  *
  1694.  *    Timestamps are stored in the skb as offsets to a base timestamp.
  1695.  *    This function converts the offset back to a struct timeval and stores
  1696.  *    it in stamp.
  1697.  */
  1698. static inline void skb_get_timestamp(const struct sk_buff *skb, struct timeval *stamp)
  1699. {
  1700.     *stamp = ktime_to_timeval(skb->tstamp);
  1701. }
  1702.  
  1703. static inline void __net_timestamp(struct sk_buff *skb)
  1704. {
  1705.     skb->tstamp = ktime_get_real();
  1706. }
  1707.  
  1708. static inline ktime_t net_timedelta(ktime_t t)
  1709. {
  1710.     return ktime_sub(ktime_get_real(), t);
  1711. }
  1712.  
  1713. static inline ktime_t net_invalid_timestamp(void)
  1714. {
  1715.     return ktime_set(0, 0);
  1716. }
  1717.  
  1718. extern __sum16 __skb_checksum_complete_head(struct sk_buff *skb, int len);
  1719. extern __sum16 __skb_checksum_complete(struct sk_buff *skb);
  1720.  
  1721. static inline int skb_csum_unnecessary(const struct sk_buff *skb)
  1722. {
  1723.     return skb->ip_summed & CHECKSUM_UNNECESSARY;
  1724. }
  1725.  
  1726. /**
  1727.  *    skb_checksum_complete - Calculate checksum of an entire packet
  1728.  *    @skb: packet to process
  1729.  *
  1730.  *    This function calculates the checksum over the entire packet plus
  1731.  *    the value of skb->csum.  The latter can be used to supply the
  1732.  *    checksum of a pseudo header as used by TCP/UDP.  It returns the
  1733.  *    checksum.
  1734.  *
  1735.  *    For protocols that contain complete checksums such as ICMP/TCP/UDP,
  1736.  *    this function can be used to verify that checksum on received
  1737.  *    packets.  In that case the function should return zero if the
  1738.  *    checksum is correct.  In particular, this function will return zero
  1739.  *    if skb->ip_summed is CHECKSUM_UNNECESSARY which indicates that the
  1740.  *    hardware has already verified the correctness of the checksum.
  1741.  */
  1742. static inline __sum16 skb_checksum_complete(struct sk_buff *skb)
  1743. {
  1744.     return skb_csum_unnecessary(skb) ?
  1745.            0 : __skb_checksum_complete(skb);
  1746. }
  1747.  
  1748. #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  1749. extern void nf_conntrack_destroy(struct nf_conntrack *nfct);
  1750. static inline void nf_conntrack_put(struct nf_conntrack *nfct)
  1751. {
  1752.     if (nfct && atomic_dec_and_test(&nfct->use))
  1753.         nf_conntrack_destroy(nfct);
  1754. }
  1755. static inline void nf_conntrack_get(struct nf_conntrack *nfct)
  1756. {
  1757.     if (nfct)
  1758.         atomic_inc(&nfct->use);
  1759. }
  1760. static inline void nf_conntrack_get_reasm(struct sk_buff *skb)
  1761. {
  1762.     if (skb)
  1763.         atomic_inc(&skb->users);
  1764. }
  1765. static inline void nf_conntrack_put_reasm(struct sk_buff *skb)
  1766. {
  1767.     if (skb)
  1768.         kfree_skb(skb);
  1769. }
  1770. #endif
  1771. #ifdef CONFIG_BRIDGE_NETFILTER
  1772. static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
  1773. {
  1774.     if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
  1775.         kfree(nf_bridge);
  1776. }
  1777. static inline void nf_bridge_get(struct nf_bridge_info *nf_bridge)
  1778. {
  1779.     if (nf_bridge)
  1780.         atomic_inc(&nf_bridge->use);
  1781. }
  1782. #endif /* CONFIG_BRIDGE_NETFILTER */
  1783. static inline void nf_reset(struct sk_buff *skb)
  1784. {
  1785. #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  1786.     nf_conntrack_put(skb->nfct);
  1787.     skb->nfct = NULL;
  1788.     nf_conntrack_put_reasm(skb->nfct_reasm);
  1789.     skb->nfct_reasm = NULL;
  1790. #endif
  1791. #ifdef CONFIG_BRIDGE_NETFILTER
  1792.     nf_bridge_put(skb->nf_bridge);
  1793.     skb->nf_bridge = NULL;
  1794. #endif
  1795. }
  1796.  
  1797. /* Note: This doesn't put any conntrack and bridge info in dst. */
  1798. static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src)
  1799. {
  1800. #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  1801.     dst->nfct = src->nfct;
  1802.     nf_conntrack_get(src->nfct);
  1803.     dst->nfctinfo = src->nfctinfo;
  1804.     dst->nfct_reasm = src->nfct_reasm;
  1805.     nf_conntrack_get_reasm(src->nfct_reasm);
  1806. #endif
  1807. #ifdef CONFIG_BRIDGE_NETFILTER
  1808.     dst->nf_bridge  = src->nf_bridge;
  1809.     nf_bridge_get(src->nf_bridge);
  1810. #endif
  1811. }
  1812.  
  1813. static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src)
  1814. {
  1815. #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
  1816.     nf_conntrack_put(dst->nfct);
  1817.     nf_conntrack_put_reasm(dst->nfct_reasm);
  1818. #endif
  1819. #ifdef CONFIG_BRIDGE_NETFILTER
  1820.     nf_bridge_put(dst->nf_bridge);
  1821. #endif
  1822.     __nf_copy(dst, src);
  1823. }
  1824.  
  1825. #ifdef CONFIG_NETWORK_SECMARK
  1826. static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
  1827. {
  1828.     to->secmark = from->secmark;
  1829. }
  1830.  
  1831. static inline void skb_init_secmark(struct sk_buff *skb)
  1832. {
  1833.     skb->secmark = 0;
  1834. }
  1835. #else
  1836. static inline void skb_copy_secmark(struct sk_buff *to, const struct sk_buff *from)
  1837. { }
  1838.  
  1839. static inline void skb_init_secmark(struct sk_buff *skb)
  1840. { }
  1841. #endif
  1842.  
  1843. static inline void skb_set_queue_mapping(struct sk_buff *skb, u16 queue_mapping)
  1844. {
  1845.     skb->queue_mapping = queue_mapping;
  1846. }
  1847.  
  1848. static inline u16 skb_get_queue_mapping(struct sk_buff *skb)
  1849. {
  1850.     return skb->queue_mapping;
  1851. }
  1852.  
  1853. static inline void skb_copy_queue_mapping(struct sk_buff *to, const struct sk_buff *from)
  1854. {
  1855.     to->queue_mapping = from->queue_mapping;
  1856. }
  1857.  
  1858. static inline int skb_is_gso(const struct sk_buff *skb)
  1859. {
  1860.     return skb_shinfo(skb)->gso_size;
  1861. }
  1862.  
  1863. static inline int skb_is_gso_v6(const struct sk_buff *skb)
  1864. {
  1865.     return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6;
  1866. }
  1867.  
  1868. extern void __skb_warn_lro_forwarding(const struct sk_buff *skb);
  1869.  
  1870. static inline bool skb_warn_if_lro(const struct sk_buff *skb)
  1871. {
  1872.     /* LRO sets gso_size but not gso_type, whereas if GSO is really
  1873.      * wanted then gso_type will be set. */
  1874.     struct skb_shared_info *shinfo = skb_shinfo(skb);
  1875.     if (shinfo->gso_size != 0 && unlikely(shinfo->gso_type == 0)) {
  1876.         __skb_warn_lro_forwarding(skb);
  1877.         return true;
  1878.     }
  1879.     return false;
  1880. }
  1881.  
  1882. static inline void skb_forward_csum(struct sk_buff *skb)
  1883. {
  1884.     /* Unfortunately we don't support this one.  Any brave souls? */
  1885.     if (skb->ip_summed == CHECKSUM_COMPLETE)
  1886.         skb->ip_summed = CHECKSUM_NONE;
  1887. }
  1888.  
  1889. bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
  1890. #endif    /* __KERNEL__ */
  1891. #endif    /* _LINUX_SKBUFF_H */
  1892.